PMD - View of -[12][146]-CPPParser[146]-3833-3882-CPPParser[146]-5161-5210-CPPParser[146]-5737-1825967934


CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser CPPParser
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing) CPPParser (full listing)
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }